home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume12 / fc / part01 next >
Encoding:
Text File  |  1990-04-17  |  30.8 KB  |  1,608 lines
  1. Newsgroups: comp.sources.misc
  2. organization: Crash TimeSharing, El Cajon, CA
  3. subject: v12i012: FC, Fast 2D Line Clipper
  4. from: jcs@crash.cts.com (John Schultz)
  5. Sender: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  6.  
  7. Posting-number: Volume 12, Issue 12
  8. Submitted-by: jcs@crash.cts.com (John Schultz)
  9. Archive-name: fc/part01
  10.  
  11. #! /bin/sh
  12. # This is a shell archive, meaning:
  13. # 1. Remove everything above the #! /bin/sh line.
  14. # 2. Save the resulting text in a file.
  15. # 3. Execute the file with /bin/sh (not csh) to create the files:
  16. #    readme
  17. #    makefile
  18. #    clip.a
  19. #    cliptest.c
  20. #    clip2d.def
  21. #    clip2d.mod
  22. # This archive created: Mon Apr 16 16:33:27 1990
  23. export PATH; PATH=/bin:$PATH
  24. if test -f 'readme'
  25. then
  26.     echo shar: will not over-write existing file "'readme'"
  27. else
  28. cat << \SHAR_EOF > 'readme'
  29.  
  30.  
  31.                      SOURCE CODE FOR THE FC CLIPPER
  32.  
  33.                             as implemented by
  34.  
  35.                               John Schultz
  36.  
  37.                                  4/15/90
  38.  
  39.  
  40.   The Fast Clipper (FC) 2D line clipper algorithm uses line encoding
  41. as opposed to end point encoding as with the Cohen-Sutherland (CS)
  42. method, or parametric methods of Liang-Barsky and Cyrus-Beck.  The
  43. Sobkow-Pospisil-Yang (SPY) paper shows benchmarks where the FC clipper
  44. is over twice as fast as the CS algorithm. The parametric methods are
  45. much slower.  The paper has a source code listing in C, which has a few
  46. errors.  These errors were in the #define statements for clipping to
  47. screen edges.  A divide and a subtract were left out:
  48.  
  49.   as published:
  50.     #define ClipPTop (*Px) = (*Px) + ((*Qx) - (*Px)) * (YTop - (*Py))
  51.  
  52.   should read:
  53.     #define ClipPTop (*Px) = (*Px) + ((*Qx) - (*Px)) * (YTop - (*Py)) /
  54.                                      ((*Qy) - (*Py))
  55.  
  56.   Once these errors were corrected, the algorithm worked properly.
  57. At the time I was experimenting with clipping, I was using a Modula-2
  58. compiler, so my HLL source is in modula-2.  The latest version is in
  59. 68000 assembly, linked to C test code.  
  60.  
  61.   The original paper on the FC algorithm was published in
  62. Computers & Graphics Vol. 11, No. 4, pp. 459-467, 1987
  63. Printed in Great Britain.  The publisher was Pergamon Journals Ltd.
  64.  
  65. Authors of the paper (and creators of the algorithm):
  66.  
  67.   Mark S. Sobkow, Paul Pospisil, and Yee-Hong Yang (to whom
  68. correspondence should be addressed), 
  69. Department of Computational Science, University of Saskatchewan, Saskatoon,
  70. Saskatchewan, Canada S7N 0W0.
  71.  
  72.  
  73.   I never tested my code against any other algorithms, so I'm curious to
  74. see if it is twice as fast as SC. Please let me know of any further
  75. optimizations.
  76.  
  77.  
  78.  
  79.   John
  80.  
  81.  
  82.  
  83.   Files for FC:
  84.  
  85.     readme
  86.     clip.a
  87.     cliptest.c
  88.     makefile
  89.     clip2d.def
  90.     clip2d.mod
  91.  
  92. SHAR_EOF
  93. fi # end of overwriting check
  94. if test -f 'makefile'
  95. then
  96.     echo shar: will not over-write existing file "'makefile'"
  97. else
  98. cat << \SHAR_EOF > 'makefile'
  99. cliptest: cliptest.o clip.o
  100.   blink from lib:c.o cliptest.o clip.o to cliptest lib lib:lc.lib \
  101.              lib:amiga.lib sd sc
  102.  
  103. cliptest.o: cliptest.c
  104.   lc -O cliptest.c
  105.  
  106. clip.o:    clip.a
  107.   comp:cape/cape -a clip.a -oclip.o
  108. SHAR_EOF
  109. fi # end of overwriting check
  110. if test -f 'clip.a'
  111. then
  112.     echo shar: will not over-write existing file "'clip.a'"
  113. else
  114. cat << \SHAR_EOF > 'clip.a'
  115. ; Clip.a,  Fast Clipper (FC).
  116.  
  117. ; A modified implementation of the Sobkow-Pospisil-Yang clipping algorithm.
  118. ; References: Computers & Graphics, Vol. 11. No. 4, pp. 459-467, 1987.
  119.  
  120. ; This algorithm uses line encoding as opposed to end point encoding.
  121.  
  122. ; Created 19-Nov-89
  123. ; by John C. Schultz
  124.  
  125.  
  126. ; Successfully assembled with Lattice 5.04 asm, CAPE 2.0, and Devpac 2.14.
  127.  
  128.  
  129.     section Clip,CODE
  130.  
  131.     xdef    _minX
  132.     xdef    _maxX
  133.     xdef    _minY
  134.     xdef    _maxY
  135.     xdef    _clipline
  136.  
  137. ; User definable clipping window.
  138.  
  139. _minX    dc.w    0        ; Popular defaults
  140. _maxX    dc.w    319
  141. _minY    dc.w    0
  142. _maxY    dc.w    199
  143.  
  144. ; code size can be reduced (with a loss of speed) by using
  145. ; bra's and bsr's instead of complete inline expanded macros.
  146.  
  147. ; ClipEdge: \2 = result, d0,d1 are scratched
  148. CLIPEDGE    MACRO        ; comments as per clip minX edge:
  149.     move.w    \1,d0        ;   copy p.y
  150.     sub.w    \2,d0        ;   d0 = p.y - s.y
  151.     move.w    \3,d1        ;   copy _minX(pc)
  152.     sub.w    \4,d1        ;   d1 = _minX(pc) - s.x
  153.     muls    d0,d1        ;   d1 = (p.y - s.y)*(_minX(pc) - s.x)
  154.     move.w    \5,d0        ;   copy p.x
  155.     sub.w    \4,d0        ;   d0 = p.x - s.x
  156.     divs    d0,d1        ;   d1 = deltay
  157.     add.w    d1,\2        ;   \2 = deltay + s.y
  158.         ENDM
  159.  
  160. clippmaxY    macro
  161.     CLIPEDGE d4,d2,_maxY(pc),d3,d5
  162.     move.w    _maxY(pc),d3
  163.         endm
  164.  
  165. clippminY    macro
  166.     CLIPEDGE d4,d2,_minY(pc),d3,d5
  167.     move.w    _minY(pc),d3
  168.         endm
  169.  
  170. clippmaxX    macro
  171.     CLIPEDGE d5,d3,_maxX(pc),d2,d4
  172.     move.w    _maxX(pc),d2
  173.         endm
  174.  
  175. clippminX    macro
  176.     CLIPEDGE d5,d3,_minX(pc),d2,d4
  177.     move.w    _minX(pc),d2
  178.         endm
  179.  
  180. clipqmaxY    macro
  181.     CLIPEDGE d2,d4,_maxY(pc),d5,d3
  182.     move.w    _maxY(pc),d5
  183.         endm
  184.  
  185. clipqminY    macro
  186.     CLIPEDGE d2,d4,_minY(pc),d5,d3
  187.     move.w    _minY(pc),d5
  188.         endm
  189.  
  190. clipqmaxX    macro
  191.     CLIPEDGE d3,d5,_maxX(pc),d4,d2
  192.     move.w    _maxX(pc),d4
  193.         endm
  194.  
  195. clipqminX    macro
  196.     CLIPEDGE d3,d5,_minX(pc),d4,d2
  197.     move.w    _minX(pc),d4
  198.         endm
  199.  
  200. accept    macro
  201.     movem.w    d2/d3/d4/d5,(a0)
  202.     moveq.l    #1,d0
  203.     movem.l    (sp)+,d2-d5
  204.     rts
  205.     endm
  206.  
  207. reject    macro
  208.     moveq.l    #0,d0
  209.     movem.l    (sp)+,d2-d5
  210.     rts
  211.     endm
  212.  
  213.  
  214. ; Fast Clipper (FC) line clipping algorithm.
  215. ; a0 = line pointer, format: px,py,qx,qy.
  216. ; d0 = return value, 1 = visible, 0 = invisible
  217. _clipline
  218.     movem.l    d2-d5,-(sp)
  219.  
  220.     movem.w    (a0),d2/d3/d4/d5 ; px,py,qx,qy
  221.  
  222. ; px = d2
  223. ; py = d3
  224. ; qx = d4
  225. ; qy = d5
  226.  
  227.     moveq.l    #0,d1        ; clear line code
  228.  
  229. ; There might be a way to do the following using ROXL, with no
  230. ; branches (10 cycles a pop)...
  231.  
  232. ; check qx,qy.
  233.  
  234. checkqmaxY
  235.     cmp.w    _maxY(pc),d5    ; y maxY ok?
  236.     ble.b    checkqminY    ; yes.
  237.     addq.w    #8,d1        ; else set code bit
  238.     bra.b    checkqmaxX
  239. checkqminY
  240.     cmp.w    _minY(pc),d5    ; y minY ok?
  241.     bge.b    checkqmaxX    ; yes.
  242.     addq.w    #4,d1        ; else set code bit
  243. checkqmaxX
  244.     cmp.w    _maxX(pc),d4    ; x maxX ok?
  245.     ble.b    checkqminX    ; yes
  246.     addq.w    #2,d1        ; else set code bit
  247. checkqminX
  248.     cmp.w    _minX(pc),d4    ; x minX ok?
  249.     bge.b    checkpmaxY    ; yes
  250.     addq.w    #1,d1        ; else set code bit
  251.  
  252. ; check px,py.
  253.  
  254. checkpmaxY
  255.     cmp.w    _maxY(pc),d3    ; y maxY ok?
  256.     ble.b    checkpminY    ; yes.
  257.     add.w    #128,d1        ; else set code bit
  258.     bra.b    checkpmaxX
  259. checkpminY
  260.     cmp.w    _minY(pc),d3    ; y minY ok?
  261.     bge.b    checkpmaxX    ; yes.
  262.     add.w    #64,d1        ; else set code bit
  263. checkpmaxX
  264.     cmp.w    _maxX(pc),d2    ; x maxX ok?
  265.     ble.b    checkpminX    ; yes
  266.     add.w    #32,d1        ; else set code bit
  267. checkpminX
  268.     cmp.w    _minX(pc),d2    ; x minX ok?
  269.     bge.b    checkcode    ; yes
  270.     add.w    #16,d1        ; else set code bit
  271.  
  272. checkcode
  273.     add.w    d1,d1        ; entries are 4 bytes
  274.     add.w    d1,d1
  275.     lea    casetable(pc),a1
  276.     movea.l    0(a1,d1.w),a1
  277.     jmp    (a1)        ; perform specific clipping action.
  278.  
  279. ; Specific line case functions.
  280.  
  281. ; From the Center
  282.  
  283. case00    accept
  284. case01    clipqminX
  285.     accept
  286. case02    clipqmaxX
  287.     accept
  288. case04    clipqminY
  289.     accept
  290. case05    clipqminX
  291.     cmp.w    _minY(pc),d5    ; qy < minY?
  292.     bge.b    1$
  293.     clipqminY
  294. 1$    accept
  295. case06    clipqmaxX
  296.     cmp.w    _minY(pc),d5    ; qy < minY?
  297.     bge.b    1$
  298.     clipqminY
  299. 1$    accept
  300. case08    clipqmaxY
  301.     accept
  302. case09    clipqminX
  303.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  304.     ble.b    1$
  305.     clipqmaxY
  306. 1$    accept
  307. case0A    clipqmaxX
  308.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  309.     ble.b    1$
  310.     clipqmaxY
  311. 1$    accept
  312.  
  313. ; From the minX
  314.  
  315. case10    clippminX
  316.     accept
  317. case11    reject
  318. case12    clippminX
  319.     clipqmaxX
  320.     accept
  321. case14    clippminX
  322.     cmp.w    _minY(pc),d3    ; py < minY?
  323.     bge.b    1$
  324.     reject
  325. 1$    clipqminY
  326.     accept
  327. case15    reject
  328. case16    clippminX
  329.     cmp.w    _minY(pc),d3    ; py < minY?
  330.     bge.b    1$
  331.     reject
  332. 1$    clipqminY
  333.     cmp.w    _maxX(pc),d4    ; qx > maxX?
  334.     ble.b    2$
  335.     clipqmaxX
  336. 2$    accept
  337. case18    clippminX
  338.     cmp.w    _maxY(pc),d3    ; py > maxY?
  339.     ble.b    1$
  340.     reject
  341. 1$    clipqmaxY
  342.     accept
  343. case19    reject
  344. case1A    clippminX
  345.     cmp.w    _maxY(pc),d3    ; py > maxY?
  346.     ble.b    1$
  347.     reject
  348. 1$    clipqmaxY
  349.     cmp.w    _maxX(pc),d4    ; qx > maxX?
  350.     ble.b    2$
  351.     clipqmaxX
  352. 2$    accept
  353.  
  354. ; From maxX
  355.  
  356. case20    clippmaxX
  357.     accept
  358. case21    clippmaxX
  359.     clipqminX
  360.     accept
  361. case22    reject
  362. case24    clippmaxX
  363.     cmp.w    _minY(pc),d3    ; py < minY?
  364.     bge.b    1$
  365.     reject
  366. 1$    clipqminY
  367.     accept
  368. case25    clippmaxX
  369.     cmp.w    _minY(pc),d3    ; py < minY?
  370.     bge.b    1$
  371.     reject
  372. 1$    clipqminY
  373.     cmp.w    _minX(pc),d4    ; qx < minX?
  374.     bge.b    2$
  375.     clipqminX
  376. 2$    accept
  377. case26    reject
  378. case28    clippmaxX
  379.     cmp.w    _maxY(pc),d3    ; py > maxY?
  380.     ble.b    1$
  381.     reject
  382. 1$    clipqmaxY
  383.     accept
  384. case29    clippmaxX
  385.     cmp.w    _maxY(pc),d3    ; py > maxY?
  386.     ble.b    1$
  387.     reject
  388. 1$    clipqmaxY
  389.     cmp.w    _minX(pc),d4    ; qx < minX?
  390.     bge.b    2$
  391.     clipqminX
  392. 2$    accept
  393. case2A    reject
  394.  
  395. ; From minY
  396.  
  397. case40    clippminY
  398.     accept
  399. case41    clippminY
  400.     cmp.w    _minX(pc),d2    ; px < minX?
  401.     bge.b    1$
  402.     reject
  403. 1$    clipqminX
  404.     cmp.w    _minY(pc),d5    ; qy < minY?
  405.     bge.b    2$
  406.     clipqminY
  407. 2$    accept
  408. case42    clippminY
  409.     cmp.w    _maxX(pc),d2    ; px > maxX?
  410.     ble.b    1$
  411.     reject
  412. 1$    clipqmaxX
  413.     accept
  414. case44    ; reject
  415. case45    ; reject
  416. case46    reject
  417. case48    clippminY
  418.     clipqmaxY
  419.     accept
  420. case49    clippminY
  421.     cmp.w    _minX(pc),d2    ; px < minX?
  422.     bge.b    1$
  423.     reject
  424. 1$    clipqminX
  425.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  426.     ble.b    2$
  427.     clipqmaxY
  428. 2$    accept
  429. case4A    clippminY
  430.     cmp.w    _maxX(pc),d2    ; px > maxX?
  431.     ble.b    1$
  432.     reject
  433. 1$    clipqmaxX
  434.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  435.     ble.b    2$
  436.     clipqmaxY
  437. 2$    accept
  438.  
  439. ; From Lower minX
  440.  
  441. case50    clippminX
  442.     cmp.w    _minY(pc),d3    ; py < minY?
  443.     bge.b    1$
  444.     clippminY
  445. 1$    accept
  446. case51    reject
  447. case52    clipqmaxX
  448.     cmp.w    _minY(pc),d5    ; qy < minY?
  449.     bge.b    1$
  450.     reject
  451. 1$    clippminY
  452.     cmp.w    _minX(pc),d2    ; px < minX?
  453.     bge.b    2$
  454.     clippminX
  455. 2$    accept
  456. case54  ; reject
  457. case55    ; reject
  458. case56    reject
  459. case58    clipqmaxY
  460.     cmp.w    _minX(pc),d4    ; qx < minX?
  461.     bge.b    1$
  462.     reject
  463. 1$    clippminY
  464.     cmp.w    _minX(pc),d2    ; px < minX?
  465.     bge.b    2$
  466.     clippminX
  467. 2$    accept
  468. case59    reject
  469. case5A    clippminX
  470.     cmp.w    _maxY(pc),d3    ; py > maxY?
  471.     ble.b    1$
  472.     reject
  473. 1$    clipqmaxX
  474.     cmp.w    _minY(pc),d5    ; qy < minY?
  475.     bge.b    2$
  476.     reject
  477. 2$    cmp.w    _minY(pc),d3    ; py < minY?
  478.     bge.b    3$
  479.     clippminY
  480. 3$    cmp.w    _maxY(pc),d5    ; qy > maxY?
  481.     ble.b    4$
  482.     clipqmaxY
  483. 4$    accept
  484.  
  485. ; From Lower maxX
  486.  
  487. case60    clippmaxX
  488.     cmp.w    _minY(pc),d3    ; py < minY?
  489.     bge.b    1$
  490.     clippminY
  491. 1$    accept
  492. case61    clipqminX
  493.     cmp.w    _minY(pc),d5    ; qy < minY?
  494.     bge.b    1$
  495.     reject
  496. 1$    clippminY
  497.     cmp.w    _maxX(pc),d2    ; px > maxX?
  498.     ble.b    2$
  499.     clippmaxX
  500. 2$    accept
  501. case62    ; reject
  502. case64    ; reject
  503. case65    ; reject
  504. case66    reject
  505. case68    clipqmaxY
  506.     cmp.w    _maxX(pc),d4    ; qx > maxX?
  507.     ble.b    1$
  508.     reject
  509. 1$    clippmaxX
  510.     cmp.w    _minY(pc),d3    ; py < minY?
  511.     bge.b    2$
  512.     clippminY
  513. 2$    accept
  514. case69    clipqminX
  515.     cmp.w    _minY(pc),d5    ; qy < minY?
  516.     bge.b    1$
  517.     reject
  518. 1$    clippmaxX
  519.     cmp.w    _maxY(pc),d3    ; py > maxY?
  520.     ble.b    2$
  521.     reject
  522. 2$    cmp.w    _maxY(pc),d5    ; qy > maxY?
  523.     ble.b    3$
  524.     clipqmaxY
  525. 3$    cmp.w    _minY(pc),d3    ; py < minY?
  526.     bge.b    4$
  527.     clippminY
  528. 4$    accept
  529. case6A    reject
  530.  
  531. ; From maxY
  532.  
  533. case80    clippmaxY
  534.     accept
  535. case81    clippmaxY
  536.     cmp.w    _minX(pc),d2    ; px < minX?
  537.     bge.b    1$
  538.     reject
  539. 1$    clipqminX
  540.     accept
  541. case82    clippmaxY
  542.     cmp.w    _maxX(pc),d2    ; px > maxX?
  543.     ble.b    1$
  544.     reject
  545. 1$    clipqmaxX
  546.     accept
  547. case84    clippmaxY
  548.     clipqminY
  549.     accept
  550. case85    clippmaxY
  551.     cmp.w    _minX(pc),d2    ; px < minX?
  552.     bge.b    1$
  553.     reject
  554. 1$    clipqminX
  555.     cmp.w    _minY(pc),d5    ; qy < minY?
  556.     bge.b    2$
  557.     clipqminY
  558. 2$    accept
  559. case86    clippmaxY
  560.     cmp.w    _maxX(pc),d2    ; px > maxX?
  561.     ble.b    1$
  562.     reject
  563. 1$    clipqmaxX
  564.     cmp.w    _minY(pc),d5    ; qy < minY?
  565.     bge.b    2$
  566.     clipqminY
  567. 2$    accept
  568. case88    ; reject
  569. case89    ; reject
  570. case8A    reject
  571.  
  572. ; From Upper minX
  573.  
  574. case90    clippminX
  575.     cmp.w    _maxY(pc),d3    ; py > maxY?
  576.     ble.b    1$
  577.     clippmaxY
  578. 1$    accept
  579. case91    reject
  580. case92    clipqmaxX
  581.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  582.     ble.b    1$
  583.     reject
  584. 1$    clippmaxY
  585.     cmp.w    _minX(pc),d2    ; px < minX?
  586.     bge.b    2$
  587.     clippminX
  588. 2$    accept
  589. case94    clipqminY
  590.     cmp.w    _minX(pc),d4    ; qx < minX?
  591.     bge.b    1$
  592.     reject
  593. 1$    clippminX
  594.     cmp.w     _maxY(pc),d3    ; py > maxY?
  595.     ble.b    2$
  596.     clippmaxY
  597. 2$    accept
  598. case95    reject
  599. case96    clippminX
  600.     cmp.w    _minY(pc),d3    ; py < minY?
  601.     bge.b    1$
  602.     reject
  603. 1$    clipqmaxX
  604.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  605.     ble.b    2$
  606.     reject
  607. 2$    cmp.w    _maxY(pc),d3    ; py > maxY?
  608.     ble.b    3$
  609.     clippmaxY
  610. 3$    cmp.w    _minY(pc),d5    ; qy < minY
  611.     bge.b    4$
  612.     clipqminY
  613. 4$    accept
  614. case98    ; reject
  615. case99    ; reject
  616. case9A    reject
  617.  
  618. ; From Upper maxX
  619.  
  620. caseA0    clippmaxX
  621.     cmp.w    _maxY(pc),d3    ; py > maxY?
  622.     ble.b    1$
  623.     clippmaxY
  624. 1$    accept
  625. caseA1    clipqminX
  626.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  627.     ble.b    1$
  628.     reject
  629. 1$    clippmaxY
  630.     cmp.w    _maxX(pc),d2    ; px > maxX?
  631.     ble.b    2$
  632.     clippmaxX
  633. 2$    accept
  634. caseA2    reject
  635. caseA4    clipqminY
  636.     cmp.w    _maxX(pc),d4    ; qx > maxX?
  637.     ble.b    1$
  638.     reject
  639. 1$    clippmaxX
  640.     cmp.w    _maxY(pc),d3    ; py > maxY?
  641.     ble.b    2$
  642.     clippmaxY
  643. 2$    accept
  644. caseA5    clipqminX
  645.     cmp.w    _maxY(pc),d5    ; qy > maxY?
  646.     ble.b    1$
  647.     reject
  648. 1$    clippmaxX
  649.     cmp.w    _minY(pc),d3    ; py < minY?
  650.     bge.b    2$
  651.     reject
  652. 2$    cmp.w    _minY(pc),d5    ; qy < minY?
  653.     bge.b    3$
  654.     clipqminY
  655. 3$    cmp.w    _maxY(pc),d3    ; py > maxY?
  656.     ble.b    4$
  657.     clippmaxY
  658. 4$    accept
  659. caseA6    ; reject
  660. caseA8    ; reject
  661. caseA9    ; reject
  662. caseAA    reject
  663.  
  664. dummycase reject
  665.     
  666. casetable
  667.     dc.l    case00
  668.     dc.l    case01
  669.     dc.l    case02
  670.  
  671.     dc.l    dummycase ; 03
  672.  
  673.     dc.l    case04
  674.     dc.l    case05
  675.     dc.l    case06
  676.  
  677.     dc.l    dummycase ; 07
  678.  
  679.     dc.l    case08
  680.     dc.l    case09
  681.     dc.l    case0A
  682.  
  683.     dc.l    dummycase ; 0B 
  684.     dc.l    dummycase ; 0C
  685.     dc.l    dummycase ; 0D
  686.     dc.l    dummycase ; 0E 
  687.     dc.l    dummycase ; 0F
  688.  
  689.     dc.l    case10
  690.     dc.l    case11
  691.     dc.l    case12
  692.  
  693.     dc.l    dummycase ; 13
  694.  
  695.     dc.l    case14
  696.     dc.l    case15
  697.     dc.l    case16
  698.  
  699.     dc.l    dummycase ; 17
  700.  
  701.     dc.l    case18
  702.     dc.l    case19
  703.     dc.l    case1A
  704.  
  705.     dc.l    dummycase ; 1B 
  706.     dc.l    dummycase ; 1C
  707.     dc.l    dummycase ; 1D
  708.     dc.l    dummycase ; 1E 
  709.     dc.l    dummycase ; 1F
  710.  
  711.     dc.l    case20
  712.     dc.l    case21
  713.     dc.l    case22
  714.  
  715.     dc.l    dummycase ; 23
  716.  
  717.     dc.l    case24
  718.     dc.l    case25
  719.     dc.l    case26
  720.  
  721.     dc.l    dummycase ; 27
  722.  
  723.     dc.l    case28
  724.     dc.l    case29
  725.     dc.l    case2A
  726.  
  727.     dc.l    dummycase ; 2B 
  728.     dc.l    dummycase ; 2C
  729.     dc.l    dummycase ; 2D
  730.     dc.l    dummycase ; 2E 
  731.     dc.l    dummycase ; 2F
  732.     dc.l    dummycase ; 30 
  733.     dc.l    dummycase ; 31
  734.     dc.l    dummycase ; 32
  735.     dc.l    dummycase ; 33 
  736.     dc.l    dummycase ; 34
  737.     dc.l    dummycase ; 35 
  738.     dc.l    dummycase ; 36
  739.     dc.l    dummycase ; 37
  740.     dc.l    dummycase ; 38 
  741.     dc.l    dummycase ; 39
  742.     dc.l    dummycase ; 3A
  743.     dc.l    dummycase ; 3B 
  744.     dc.l    dummycase ; 3C
  745.     dc.l    dummycase ; 3D
  746.     dc.l    dummycase ; 3E 
  747.     dc.l    dummycase ; 3F
  748.  
  749.     dc.l    case40
  750.     dc.l    case41
  751.     dc.l    case42
  752.  
  753.     dc.l    dummycase ; 43
  754.  
  755.     dc.l    case44
  756.     dc.l    case45
  757.     dc.l    case46
  758.  
  759.     dc.l    dummycase ; 47
  760.  
  761.     dc.l    case48
  762.     dc.l    case49
  763.     dc.l    case4A
  764.  
  765.     dc.l    dummycase ; 4B 
  766.     dc.l    dummycase ; 4C
  767.     dc.l    dummycase ; 4D
  768.     dc.l    dummycase ; 4E 
  769.     dc.l    dummycase ; 4F
  770.  
  771.     dc.l    case50
  772.     dc.l    case51
  773.     dc.l    case52
  774.  
  775.     dc.l    dummycase ; 53
  776.  
  777.     dc.l    case54
  778.     dc.l    case55
  779.     dc.l    case56
  780.  
  781.     dc.l    dummycase ; 57
  782.  
  783.     dc.l    case58
  784.     dc.l    case59
  785.     dc.l    case5A
  786.  
  787.     dc.l    dummycase ; 5B 
  788.     dc.l    dummycase ; 5C
  789.     dc.l    dummycase ; 5D
  790.     dc.l    dummycase ; 5E 
  791.     dc.l    dummycase ; 5F
  792.  
  793.     dc.l    case60
  794.     dc.l    case61
  795.     dc.l    case62
  796.  
  797.     dc.l    dummycase ; 63
  798.  
  799.     dc.l    case64
  800.     dc.l    case65
  801.     dc.l    case66
  802.  
  803.     dc.l    dummycase ; 67
  804.  
  805.     dc.l    case68
  806.     dc.l    case69
  807.     dc.l    case6A
  808.  
  809.     dc.l    dummycase ; 6B 
  810.     dc.l    dummycase ; 6C
  811.     dc.l    dummycase ; 6D
  812.     dc.l    dummycase ; 6E 
  813.     dc.l    dummycase ; 6F
  814.  
  815.     dc.l    dummycase ; 70 
  816.     dc.l    dummycase ; 71
  817.     dc.l    dummycase ; 72
  818.     dc.l    dummycase ; 73 
  819.     dc.l    dummycase ; 74
  820.     dc.l    dummycase ; 75 
  821.     dc.l    dummycase ; 76
  822.     dc.l    dummycase ; 77
  823.     dc.l    dummycase ; 78 
  824.     dc.l    dummycase ; 79
  825.     dc.l    dummycase ; 7A
  826.     dc.l    dummycase ; 7B 
  827.     dc.l    dummycase ; 7C
  828.     dc.l    dummycase ; 7D
  829.     dc.l    dummycase ; 7E 
  830.     dc.l    dummycase ; 7F
  831.  
  832.     dc.l    case80
  833.     dc.l    case81
  834.     dc.l    case82
  835.  
  836.     dc.l    dummycase ; 83
  837.  
  838.     dc.l    case84
  839.     dc.l    case85
  840.     dc.l    case86
  841.  
  842.     dc.l    dummycase ; 87
  843.  
  844.     dc.l    case88
  845.     dc.l    case89
  846.     dc.l    case8A
  847.  
  848.     dc.l    dummycase ; 8B 
  849.     dc.l    dummycase ; 8C
  850.     dc.l    dummycase ; 8D
  851.     dc.l    dummycase ; 8E 
  852.     dc.l    dummycase ; 8F
  853.  
  854.     dc.l    case90
  855.     dc.l    case91
  856.     dc.l    case92
  857.  
  858.     dc.l    dummycase ; 93
  859.  
  860.     dc.l    case94
  861.     dc.l    case95
  862.     dc.l    case96
  863.  
  864.     dc.l    dummycase ; 97
  865.  
  866.     dc.l    case98
  867.     dc.l    case99
  868.     dc.l    case9A
  869.  
  870.     dc.l    dummycase ; 9B 
  871.     dc.l    dummycase ; 9C
  872.     dc.l    dummycase ; 9D
  873.     dc.l    dummycase ; 9E 
  874.     dc.l    dummycase ; 9F
  875.  
  876.     dc.l    caseA0
  877.     dc.l    caseA1
  878.     dc.l    caseA2
  879.  
  880.     dc.l    dummycase ; A3
  881.  
  882.     dc.l    caseA4
  883.     dc.l    caseA5
  884.     dc.l    caseA6
  885.  
  886.     dc.l    dummycase ; A7
  887.  
  888.     dc.l    caseA8
  889.     dc.l    caseA9
  890.     dc.l    caseAA
  891.     
  892.     END
  893. SHAR_EOF
  894. fi # end of overwriting check
  895. if test -f 'cliptest.c'
  896. then
  897.     echo shar: will not over-write existing file "'cliptest.c'"
  898. else
  899. cat << \SHAR_EOF > 'cliptest.c'
  900. /* Cliptest.c, by John Schultz, a modification of: */
  901.  
  902. /* This is a line drawing demo for the Commodore/Amiga  */
  903. /* Written by    John Riley, Lattice, Inc.        */
  904. /*                             */
  905.  
  906. #include <exec/types.h>
  907. #include <exec/nodes.h>
  908. #include <exec/lists.h>
  909. #include <intuition/intuition.h>
  910. #include <graphics/text.h>
  911. #include <proto/exec.h>
  912. #include <proto/graphics.h>
  913. #include <proto/intuition.h>
  914. #include <hardware/custom.h>
  915.  
  916. /***************** This is all you need for the FC clipper **************/
  917.  
  918. typedef struct {short px,py,qx,qy;} line;
  919.  
  920. extern short __asm clipline(register __a0 line * l);
  921.  
  922. extern unsigned short far minX,far minY,far maxX,far maxY;
  923.  
  924. /************************************************************************/
  925.  
  926. line l;
  927.  
  928. extern struct Custom far custom;
  929.                                             
  930. USHORT wakeup;    /* Wake me up for event */
  931. USHORT class;    /* Intu event class */
  932. USHORT code;    /* Intu event code */
  933.  
  934. struct Window *w;
  935. struct RastPort *rp,*cdrp;
  936. struct ViewPort *vp;
  937. struct IntuiMessage *message;
  938. int event(void);
  939. long rand(void);
  940. void srand(int);
  941.  
  942. /************************ Window Defines ********************************/
  943.  
  944. struct NewWindow nw = {
  945.         0,0,            /* Starting corner */
  946.         80,40,            /* Width, height */
  947.         2,1,            /* detail, block pens */
  948.     CLOSEWINDOW | NEWSIZE,        /* IDCMP flags */
  949.     WINDOWDEPTH | WINDOWDRAG | WINDOWCLOSE | GIMMEZEROZERO | WINDOWSIZING,
  950.                     /* Window flags */
  951.         NULL,            /* Pointer to first gadget */
  952.         NULL,            /* Pointer to checkmark */
  953.         "FC Clipper Test",    /* title */
  954.         NULL,            /* screen pointer */
  955.         NULL,            /* bitmap pointer */
  956.         0,0,640,400,        /* window not sized */
  957.         WBENCHSCREEN        /* type of screen */
  958.         };
  959.  
  960. int co,xlim,ylim;
  961.  
  962. short centerx,centery;
  963.  
  964. main(int argc,char * argv[])
  965. {
  966.   unsigned short linesize,halflinesize;
  967.  
  968.   if (argc > 1) {
  969.     linesize = atoi(argv[1]);
  970.     if (linesize > 32767) {
  971.       printf("Maximum line size exceeded, using 32767 (max).\n");
  972.       linesize = 32767;
  973.     }
  974.   } else {
  975.     printf("USAGE: cliptest <linesize>\n");
  976.     printf("  using default linesize of 500.\n");
  977.     linesize = 500;
  978.   } 
  979.   halflinesize = linesize >> 1;
  980.  
  981.  
  982. /************************ Set-Up routines **********************************/
  983.     GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0);
  984.     if(GfxBase == NULL) return;
  985.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
  986.     if(IntuitionBase == NULL) 
  987.         {
  988.         CloseLibrary((struct Library *)GfxBase);
  989.         return;
  990.         }
  991.     w = OpenWindow(&nw);
  992.     rp = w->RPort;            /* Get the raster port pointer */
  993.     vp = &w->WScreen->ViewPort;    /* Get the view port pointer */
  994.     SetAPen(rp,3);            /* Set foreground pen to white */
  995.     SetDrMd(rp,JAM1);        /* Draw with foreground pen */
  996.  
  997.     minX = 0;
  998.     minY = 0;
  999.     maxX = w->Width-1;
  1000.     maxY = w->Height-1;
  1001.  
  1002.     centerx = w->Width >> 1;
  1003.     centery = w->Height >> 1;
  1004.  
  1005.     co = 1;
  1006.     do {
  1007.  
  1008.  /**************************  FC clipper test code *************************/
  1009.  
  1010.                 srand(custom.vhposr); /* video beam position */
  1011.         SetAPen(rp,co);
  1012.                 co = (co+1) & 3;
  1013.  
  1014.                 l.px = (rand() & linesize) - halflinesize + centerx;
  1015.                 l.py = (rand() & linesize) - halflinesize + centery;
  1016.                 l.qx = (rand() & linesize) - halflinesize + centerx;
  1017.                 l.qy = (rand() & linesize) - halflinesize + centery;
  1018.  
  1019.                 if (clipline(&l)) {
  1020.                   if ((l.px < minX) || (l.px > maxX)
  1021.                    || (l.py < minY) || (l.py > maxY)  
  1022.                    || (l.qx < minX) || (l.qx > maxX)
  1023.                    || (l.qy < minY) || (l.qy > maxY)) {
  1024.                     printf("FC Clip Error.\n");
  1025.                   } else {  
  1026.                     Move(rp,l.px,l.py);
  1027.             Draw(rp,l.qx,l.qy);
  1028.                   }
  1029.                 }
  1030.  
  1031.  /************************** End FC clipper test code ***********************/
  1032.  
  1033.         if(w->UserPort->mp_SigBit)
  1034.         {
  1035.             message = (struct IntuiMessage *)GetMsg(w->UserPort);
  1036.             if(message != NULL)
  1037.             {
  1038.                 class = message->Class;
  1039.                 code = message->Code;
  1040.                 ReplyMsg((struct Message *)message);
  1041.             }
  1042.         }
  1043.     } while(event());
  1044.     CloseWindow(w);
  1045.     CloseLibrary((struct Library *)GfxBase);
  1046.     CloseLibrary((struct Library *)IntuitionBase);
  1047. }
  1048.  
  1049. int event()
  1050. {
  1051.     switch(class)
  1052.     {
  1053.         case CLOSEWINDOW:
  1054.             return(0);
  1055.         case NEWSIZE:
  1056.                 maxX = w->Width-1;
  1057.             maxY = w->Height-1;
  1058.              centerx = w->Width >> 1;
  1059.             centery = w->Height >> 1;
  1060.             return(1);
  1061.  
  1062.     }
  1063.     return(1);
  1064. }
  1065. SHAR_EOF
  1066. fi # end of overwriting check
  1067. if test -f 'clip2d.def'
  1068. then
  1069.     echo shar: will not over-write existing file "'clip2d.def'"
  1070. else
  1071. cat << \SHAR_EOF > 'clip2d.def'
  1072. DEFINITION MODULE clip2d;
  1073.  
  1074. VAR
  1075.   XLeft,XRight,YTop,YBottom : INTEGER;
  1076.  
  1077. PROCEDURE clip2d(VAR px,py,qx,qy : INTEGER): BOOLEAN;
  1078.  
  1079. END clip2d.
  1080. SHAR_EOF
  1081. fi # end of overwriting check
  1082. if test -f 'clip2d.mod'
  1083. then
  1084.     echo shar: will not over-write existing file "'clip2d.mod'"
  1085. else
  1086. cat << \SHAR_EOF > 'clip2d.mod'
  1087. IMPLEMENTATION MODULE clip2d;
  1088.  
  1089. VAR
  1090.   code : CARDINAL;
  1091.  
  1092. PROCEDURE clip2d(VAR px,py,qx,qy : INTEGER): BOOLEAN;
  1093.  
  1094. PROCEDURE ClipPBottom;
  1095. BEGIN
  1096.   px := (qx - px)*(YBottom - py) DIV (qy - py) + px;
  1097.   py := YBottom;
  1098. END ClipPBottom;
  1099.  
  1100. PROCEDURE ClipPTop;
  1101. BEGIN
  1102.   px := (qx - px)*(YTop - py) DIV (qy - py) + px;
  1103.   py := YTop;
  1104. END ClipPTop;
  1105.  
  1106. PROCEDURE ClipPRight;
  1107. BEGIN
  1108.   py := (qy - py)*(XRight - px) DIV (qx - px) + py;
  1109.   px := XRight;
  1110. END ClipPRight;
  1111.  
  1112. PROCEDURE ClipPLeft;
  1113. BEGIN
  1114.   py := (qy - py)*(XLeft - px) DIV (qx - px) + py;
  1115.   px := XLeft;
  1116. END ClipPLeft;
  1117.  
  1118. PROCEDURE ClipQBottom;
  1119. BEGIN
  1120.   qx := (px - qx)*(YBottom - qy) DIV (py - qy) + qx;
  1121.   qy := YBottom;
  1122. END ClipQBottom;
  1123.  
  1124. PROCEDURE ClipQTop;
  1125. BEGIN
  1126.   qx := (px - qx)*(YTop - qy) DIV (py - qy) + qx;
  1127.   qy := YTop;
  1128. END ClipQTop;
  1129.  
  1130. PROCEDURE ClipQRight;
  1131. BEGIN
  1132.   qy := (py - qy)*(XRight - qx) DIV (px - qx) + qy;
  1133.   qx := XRight;
  1134. END ClipQRight;
  1135.  
  1136. PROCEDURE ClipQLeft;
  1137. BEGIN
  1138.   qy := (py - qy)*(XLeft - qx) DIV (px - qx) + qy;
  1139.   qx := XLeft;
  1140. END ClipQLeft;
  1141.  
  1142. BEGIN
  1143.   code := 0;
  1144.   
  1145.   IF qy > YBottom THEN
  1146.     INC(code,8);
  1147.   ELSIF qy < YTop THEN
  1148.     INC(code,4);
  1149.   END;
  1150.  
  1151.   IF qx > XRight THEN
  1152.     INC(code,2);
  1153.   ELSIF qx < XLeft THEN
  1154.     INC(code,1);
  1155.   END;
  1156.  
  1157.   IF py > YBottom THEN
  1158.     INC(code,128);
  1159.   ELSIF py < YTop THEN
  1160.     INC(code,64);
  1161.   END;
  1162.  
  1163.   IF px > XRight THEN
  1164.     INC(code,32);
  1165.   ELSIF px < XLeft THEN
  1166.     INC(code,16);
  1167.   END;
  1168.   
  1169.   CASE code OF
  1170.  
  1171.    (**************  From Center ***************)
  1172.  
  1173.     00H : RETURN TRUE;
  1174.   | 01H : ClipQLeft; 
  1175.           RETURN TRUE;
  1176.   | 02H : ClipQRight; 
  1177.           RETURN TRUE;
  1178.   | 04H : ClipQTop;
  1179.           RETURN TRUE;
  1180.   | 05H : ClipQLeft;
  1181.           IF qy < YTop THEN
  1182.             ClipQTop;
  1183.           END;
  1184.           RETURN TRUE;
  1185.   | 06H : ClipQRight;
  1186.           IF qy < YTop THEN
  1187.             ClipQTop;
  1188.           END;
  1189.           RETURN TRUE;
  1190.   | 08H : ClipQBottom;
  1191.           RETURN TRUE;
  1192.   | 09H : ClipQLeft;
  1193.           IF qy > YBottom THEN
  1194.             ClipQBottom;
  1195.           END;
  1196.           RETURN TRUE;
  1197.   | 0AH : ClipQRight;
  1198.           IF qy > YBottom THEN
  1199.             ClipQBottom;
  1200.           END;
  1201.           RETURN TRUE;
  1202.  
  1203.   (**************  From Left ***************)
  1204.  
  1205.   | 10H : ClipPLeft;
  1206.           RETURN TRUE;
  1207.   | 11H : RETURN FALSE;
  1208.   | 12H : ClipPLeft;
  1209.           ClipQRight;
  1210.           RETURN TRUE;
  1211.   | 14H : ClipPLeft;
  1212.           IF py < YTop THEN
  1213.             RETURN FALSE;
  1214.           ELSE
  1215.             ClipQTop;
  1216.             RETURN TRUE;
  1217.           END;
  1218.   | 15H : RETURN FALSE;
  1219.   | 16H : ClipPLeft;
  1220.           IF py < YTop THEN
  1221.             RETURN FALSE;
  1222.           ELSE
  1223.             ClipQTop;
  1224.             IF qx > XRight THEN
  1225.               ClipQRight;
  1226.             END;
  1227.             RETURN TRUE;
  1228.           END;
  1229.   | 18H : ClipPLeft;
  1230.           IF py > YBottom THEN
  1231.             RETURN FALSE;
  1232.           ELSE
  1233.             ClipQBottom;
  1234.             RETURN TRUE;
  1235.           END;
  1236.   | 19H : RETURN FALSE;
  1237.   | 1AH : ClipPLeft;
  1238.           IF py > YBottom THEN
  1239.             RETURN FALSE;
  1240.           ELSE
  1241.             ClipQBottom;
  1242.             IF qx > XRight THEN
  1243.               ClipQRight;
  1244.             END;
  1245.             RETURN TRUE;
  1246.           END;
  1247.  
  1248.   (**************  From Right ***************)
  1249.  
  1250.   | 20H : ClipPRight;
  1251.           RETURN TRUE;
  1252.   | 21H : ClipPRight;
  1253.           ClipQLeft;
  1254.           RETURN TRUE;
  1255.   | 22H : RETURN FALSE;
  1256.   | 24H : ClipPRight;
  1257.           IF py < YTop THEN
  1258.             RETURN FALSE;
  1259.           ELSE
  1260.             ClipQTop;
  1261.             RETURN TRUE;
  1262.           END;
  1263.   | 25H : ClipPRight;
  1264.           IF py < YTop THEN
  1265.             RETURN FALSE;
  1266.           ELSE
  1267.             ClipQTop;
  1268.             IF qx < XLeft THEN
  1269.               ClipQLeft;
  1270.             END;
  1271.             RETURN TRUE;
  1272.           END;
  1273.   | 26H : RETURN FALSE;
  1274.   | 28H : ClipPRight;
  1275.           IF py > YBottom THEN
  1276.             RETURN FALSE;
  1277.           ELSE
  1278.             ClipQBottom;
  1279.             RETURN TRUE;
  1280.           END;
  1281.   | 29H : ClipPRight;
  1282.           IF py > YBottom THEN
  1283.             RETURN FALSE;
  1284.           ELSE
  1285.             ClipQBottom;
  1286.             IF qx < XLeft THEN
  1287.               ClipQLeft;
  1288.             END;
  1289.             RETURN TRUE;
  1290.           END;
  1291.   | 2AH : RETURN FALSE;
  1292.    
  1293.   (**************  From Top ***************)
  1294.  
  1295.   | 40H : ClipPTop;
  1296.           RETURN TRUE;
  1297.   | 41H : ClipPTop;
  1298.           IF px < XLeft THEN
  1299.             RETURN FALSE;
  1300.           ELSE
  1301.             ClipQLeft;
  1302.             IF qy < YTop THEN
  1303.               ClipQTop;
  1304.             END;
  1305.             RETURN TRUE;
  1306.           END;
  1307.   | 42H : ClipPTop;
  1308.           IF px > XRight THEN
  1309.             RETURN FALSE;
  1310.           ELSE
  1311.             ClipQRight;
  1312.             RETURN TRUE;
  1313.           END;
  1314.   | 44H : RETURN FALSE;
  1315.   | 45H : RETURN FALSE;
  1316.   | 46H : RETURN FALSE;
  1317.   | 48H : ClipPTop;
  1318.           ClipQBottom;
  1319.           RETURN TRUE;
  1320.   | 49H : ClipPTop;
  1321.           IF px < XLeft THEN
  1322.             RETURN FALSE;
  1323.           ELSE
  1324.             ClipQLeft;
  1325.             IF qy > YBottom THEN
  1326.               ClipQBottom;
  1327.             END;
  1328.             RETURN TRUE;
  1329.           END;
  1330.   | 4AH : ClipPTop;
  1331.           IF px > XRight THEN
  1332.             RETURN FALSE;
  1333.           ELSE
  1334.             ClipQRight;
  1335.             IF qy > YBottom THEN
  1336.               ClipQBottom;
  1337.             END;
  1338.             RETURN TRUE;
  1339.           END;
  1340.  
  1341.   (**************  From Bottom ***************)
  1342.  
  1343.   | 50H : ClipPLeft;
  1344.           IF py < YTop THEN
  1345.             ClipPTop;
  1346.           END;
  1347.           RETURN TRUE;
  1348.   | 51H : RETURN FALSE;
  1349.   | 52H : ClipQRight;
  1350.           IF qy < YTop THEN
  1351.             RETURN FALSE;
  1352.           ELSE
  1353.             ClipPTop;
  1354.             IF px < XLeft THEN
  1355.               ClipPLeft;
  1356.             END;
  1357.             RETURN TRUE;
  1358.           END;
  1359.   | 54H : RETURN FALSE;
  1360.   | 55H : RETURN FALSE;
  1361.   | 56H : RETURN FALSE;
  1362.   | 58H : ClipQBottom;
  1363.           IF qx < XLeft THEN
  1364.             RETURN FALSE;
  1365.           ELSE
  1366.             ClipPTop;
  1367.             IF px < XLeft THEN
  1368.               ClipPLeft;
  1369.             END;
  1370.             RETURN TRUE;
  1371.           END;
  1372.   | 59H : RETURN FALSE;
  1373.   | 5AH : ClipPLeft;
  1374.           IF py > YBottom THEN
  1375.             RETURN FALSE;
  1376.           ELSE
  1377.             ClipQRight;
  1378.             IF qy < YTop THEN
  1379.               RETURN FALSE;
  1380.             ELSE
  1381.               IF py < YTop THEN
  1382.                 ClipPTop;
  1383.               END;
  1384.               IF qy > YBottom THEN
  1385.                 ClipQBottom;
  1386.               END;
  1387.               RETURN TRUE;
  1388.             END;
  1389.           END;
  1390.  
  1391.   (**************  From Lower Right ***************)
  1392.  
  1393.   | 60H : ClipPRight;
  1394.           IF py < YTop THEN
  1395.             ClipPTop;
  1396.           END;
  1397.           RETURN TRUE;
  1398.   | 61H : ClipQLeft;
  1399.           IF qy < YTop THEN
  1400.             RETURN FALSE;
  1401.           ELSE
  1402.             ClipPTop;
  1403.             IF px > XRight THEN
  1404.               ClipPRight;
  1405.             END;
  1406.             RETURN TRUE;
  1407.           END;
  1408.   | 62H : RETURN FALSE;
  1409.   | 64H : RETURN FALSE;
  1410.   | 65H : RETURN FALSE;
  1411.   | 66H : RETURN FALSE;
  1412.   | 68H : ClipQBottom;
  1413.           IF qx > XRight THEN
  1414.             RETURN FALSE;
  1415.           ELSE
  1416.             ClipPRight;
  1417.             IF py < YTop THEN
  1418.               ClipPTop;
  1419.             END;
  1420.             RETURN TRUE;
  1421.           END;
  1422.   | 69H : ClipQLeft;
  1423.           IF qy < YTop THEN
  1424.             RETURN FALSE;
  1425.           ELSE
  1426.             ClipPRight;
  1427.             IF py > YBottom THEN
  1428.               RETURN FALSE;
  1429.             ELSE
  1430.               IF qy > YBottom THEN
  1431.                 ClipQBottom;
  1432.               END;
  1433.               IF py < YTop THEN
  1434.                 ClipPTop;
  1435.               END;
  1436.               RETURN TRUE;
  1437.             END;
  1438.           END;
  1439.   | 6AH : RETURN FALSE;
  1440.  
  1441.   (**************  From Bottom ***************)
  1442.    
  1443.   | 80H : ClipPBottom;
  1444.           RETURN TRUE;
  1445.   | 81H : ClipPBottom;
  1446.           IF px < XLeft THEN
  1447.             RETURN FALSE;
  1448.           ELSE
  1449.             ClipQLeft;
  1450.             RETURN TRUE;
  1451.           END;
  1452.   | 82H : ClipPBottom;
  1453.           IF px > XRight THEN
  1454.             RETURN FALSE;
  1455.           ELSE
  1456.             ClipQRight;
  1457.             RETURN TRUE;
  1458.           END;
  1459.   | 84H : ClipPBottom;
  1460.           ClipQTop;
  1461.           RETURN TRUE;
  1462.   | 85H : ClipPBottom;
  1463.           IF px < XLeft THEN
  1464.             RETURN FALSE;
  1465.           ELSE
  1466.             ClipQLeft;
  1467.             IF qy < YTop THEN
  1468.               ClipQTop;
  1469.             END;
  1470.             RETURN TRUE;
  1471.           END;
  1472.   | 86H : ClipPBottom;
  1473.           IF px > XRight THEN
  1474.             RETURN FALSE;
  1475.           ELSE
  1476.             ClipQRight;
  1477.             IF qy < YTop THEN
  1478.               ClipQTop;
  1479.             END;
  1480.             RETURN TRUE;
  1481.           END;
  1482.   | 88H : RETURN FALSE;
  1483.   | 89H : RETURN FALSE;
  1484.   | 8AH : RETURN FALSE;
  1485.  
  1486.   (**************  From Bottom ***************)
  1487.  
  1488.   | 90H : ClipPLeft;
  1489.           IF py > YBottom THEN
  1490.             ClipPBottom;
  1491.           END;
  1492.           RETURN TRUE;
  1493.   | 91H : RETURN FALSE;
  1494.   | 92H : ClipQRight;
  1495.           IF qy > YBottom THEN
  1496.             RETURN FALSE;
  1497.           ELSE
  1498.             ClipPBottom;
  1499.             IF px < XLeft THEN
  1500.               ClipPLeft;
  1501.             END;
  1502.             RETURN TRUE;
  1503.           END;
  1504.   | 94H : ClipQTop;
  1505.           IF qx < XLeft THEN
  1506.             RETURN FALSE;
  1507.           ELSE
  1508.             ClipPLeft;
  1509.             IF py > YBottom THEN
  1510.               ClipPBottom;
  1511.             END;
  1512.             RETURN TRUE;
  1513.           END;
  1514.   | 95H : RETURN FALSE;
  1515.   | 96H : ClipPLeft;
  1516.           IF py < YTop THEN
  1517.             RETURN FALSE;
  1518.           ELSE
  1519.             ClipQRight;
  1520.             IF qy > YBottom THEN
  1521.               RETURN FALSE;
  1522.             ELSE
  1523.               IF py > YBottom THEN
  1524.                 ClipPBottom;
  1525.               END;
  1526.               IF qy < YTop THEN
  1527.                 ClipQTop;
  1528.               END;
  1529.               RETURN TRUE;
  1530.             END;
  1531.           END;
  1532.   | 98H : RETURN FALSE;
  1533.   | 99H : RETURN FALSE;
  1534.   | 9AH : RETURN FALSE;
  1535.  
  1536.   (**************  From Bottom ***************)
  1537.  
  1538.   | 0A0H : ClipPRight;
  1539.            IF py > YBottom THEN
  1540.              ClipPBottom;
  1541.            END;
  1542.            RETURN TRUE;
  1543.   | 0A1H : ClipQLeft;
  1544.            IF qy > YBottom THEN
  1545.              RETURN FALSE;
  1546.            ELSE
  1547.              ClipPBottom;
  1548.              IF px > XRight THEN 
  1549.                ClipPRight;
  1550.              END;
  1551.              RETURN TRUE;
  1552.            END;
  1553.   | 0A2H : RETURN FALSE;
  1554.   | 0A4H : ClipQTop;
  1555.            IF qx > XRight THEN
  1556.              RETURN FALSE;
  1557.            ELSE
  1558.              ClipPRight;
  1559.              IF py > YBottom THEN
  1560.                ClipPBottom;
  1561.              END;
  1562.              RETURN TRUE;
  1563.            END;
  1564.   | 0A5H : ClipQLeft;
  1565.            IF qy > YBottom THEN
  1566.              RETURN FALSE;
  1567.            ELSE
  1568.              ClipPRight;
  1569.              IF py < YTop THEN
  1570.                RETURN FALSE;
  1571.              ELSE
  1572.                IF qy < YTop THEN
  1573.                  ClipQTop;
  1574.                END;
  1575.                IF py > YBottom THEN
  1576.                  ClipPBottom;
  1577.                END;
  1578.                RETURN TRUE;
  1579.              END;
  1580.            END;
  1581.   | 0A6H : RETURN FALSE;
  1582.   | 0A8H : RETURN FALSE;
  1583.   | 0A9H : RETURN FALSE;
  1584.   | 0AAH : RETURN FALSE;
  1585.  
  1586.   (************** Error Trap ***************)
  1587.  
  1588.   ELSE  (* Undefined Code *)
  1589.  
  1590.     RETURN FALSE;
  1591.  
  1592.   END; (* CASE code *)
  1593.  
  1594. END clip2d;
  1595.  
  1596. BEGIN
  1597.   XLeft   := 0;
  1598.   XRight  := 319;
  1599.   YTop    := 0;
  1600.   YBottom := 199;
  1601. END clip2d.
  1602. SHAR_EOF
  1603. fi # end of overwriting check
  1604. #    End of shell archive
  1605. exit 0
  1606.  
  1607.  
  1608.